// culture.js
const nameMessages = require('../../utils/nameGenerationMessages.js');

Page({
  data: {
    traits: [], // 存储选中的特质数组
    selectedTraits: {}, // 存储特质选中状态的对象
    expectation: '',
    isFormValid: false,
    formData: null,
    maxTraits: 3, // 最多可选特质数量
    isGenerating: false,
    // 广告相关状态
    adCompleted: false,
    apiCompleted: false,
    apiResult: null,
    messageTimers: {
      firstTimer: null,
      interval: null
    }
  },

  onLoad(options) {
    // 获取从首页传递的表单数据
    try {
      const eventChannel = this.getOpenerEventChannel();
      if (eventChannel) {
        eventChannel.on('formData', (data) => {
          console.log('文化典故页面接收到的表单数据:', data);
          console.log('文化典故页面接收到的姓氏:', data.surname);
          this.setData({
            formData: data
          });
        });
      } else {
        console.log('eventChannel 不存在，可能直接打开了页面');
        // 设置默认值
        this.setData({
          formData: {
            surname: options.surname || '张',
            gender: options.gender || 'male',
            nameCount: options.nameCount || 2
          }
        });
      }
    } catch (error) {
      console.error('获取eventChannel时出错:', error);
      // 设置默认值
      this.setData({
        formData: {
          surname: options.surname || '张',
          gender: options.gender || 'male',
          nameCount: options.nameCount || 2
        }
      });
    }
    
    // 显示页面导航栏加载动画
    wx.showNavigationBarLoading();
    
    // 模拟数据加载完成
    setTimeout(() => {
      wx.hideNavigationBarLoading();
    }, 500);

    // 创建激励广告实例
    this.createRewardedVideoAd();
  },
  
  // 处理特质标签的选择
  toggleTrait(e) {
    const trait = e.currentTarget.dataset.trait;
    let traits = [...this.data.traits];
    let selectedTraits = {...this.data.selectedTraits};
    
    if (selectedTraits[trait]) {
      // 如果已选中，则取消选中
      delete selectedTraits[trait];
      const index = traits.indexOf(trait);
      if (index > -1) {
        traits.splice(index, 1);
      }
    } else {
      // 处理"经典典故无限制"与其他典籍的互斥关系
      if (trait === "经典典故无限制") {
        // 如果选择了"经典典故无限制"，清空其他所有选择
        traits = [];
        selectedTraits = {};
        // 添加"经典典故无限制"
        traits.push(trait);
        selectedTraits[trait] = true;
      } else {
        // 如果选择了其他典籍，但已经选了"经典典故无限制"，则清除"经典典故无限制"
        if (selectedTraits["经典典故无限制"]) {
          const index = traits.indexOf("经典典故无限制");
          if (index > -1) {
            traits.splice(index, 1);
          }
          delete selectedTraits["经典典故无限制"];
        }
        
        // 如果未选中，则检查是否已达到最大选择数量
        if (traits.length >= this.data.maxTraits) {
          wx.showToast({
            title: `最多选择${this.data.maxTraits}个特质`,
            icon: 'none',
            duration: 1500
          });
          return;
        }
        
        // 添加选中项
        selectedTraits[trait] = true;
        if (!traits.includes(trait)) {
          traits.push(trait);
        }
      }
    }

    this.setData({
      traits: traits,
      selectedTraits: selectedTraits
    }, () => {
      // 在状态更新后检查表单有效性
      this.checkFormValid();
    });
    
    console.log('选中的特质:', this.data.traits);
    console.log('特质状态:', this.data.selectedTraits);
    
    // 添加触感反馈
    wx.vibrateShort({
      type: 'light'
    });
  },
  
  // 从已选特质中移除
  removeTrait(e) {
    const trait = e.currentTarget.dataset.trait;
    let traits = [...this.data.traits];
    let selectedTraits = {...this.data.selectedTraits};
    
    const index = traits.indexOf(trait);
    if (index > -1) {
      traits.splice(index, 1);
      delete selectedTraits[trait];
      
      this.setData({
        traits: traits,
        selectedTraits: selectedTraits
      }, () => {
        // 在状态更新后检查表单有效性
        this.checkFormValid();
      });
    }
  },

  // 处理期望输入
  onExpectationInput(e) {
    this.setData({
      expectation: e.detail.value
    }, () => {
      // 在状态更新后检查表单有效性
      this.checkFormValid();
    });
  },
  
  // 使用期望示例
  useExpectationExample(e) {
    const exampleText = e.currentTarget.dataset.text;
    // 截取前30个字符
    const truncatedText = exampleText.substring(0, 30);
    
    this.setData({
      expectation: truncatedText
    }, () => {
      // 在状态更新后检查表单有效性
      this.checkFormValid();
    });
    
    // 显示提示
    wx.showToast({
      title: '已填入示例',
      icon: 'success',
      duration: 1000
    });
  },
  
  // 返回上一页
  goBack() {
    // 如果用户已经输入内容，提示确认
    if (this.data.traits.length > 0 || this.data.expectation) {
      wx.showModal({
        title: '确认返回',
        content: '您已填写的内容将不会保存，确定要返回吗？',
        confirmColor: '#6B238E',
        success: (res) => {
          if (res.confirm) {
            wx.navigateBack();
          }
        }
      });
    } else {
      wx.navigateBack();
    }
  },

  // 检查表单是否有效
  checkFormValid() {
    const { expectation } = this.data;
    // 修改验证逻辑：只要求填写期望寄语
    const hasExpectation = expectation.trim().length > 0;
    const isValid = hasExpectation;
    
    this.setData({
      isFormValid: isValid
    });
    
    // 只有当表单无效时，才提示用户填写期望寄语
    if (!isValid) {
      wx.showToast({
        title: '请填写期望寄语',
        icon: 'none',
        duration: 1500
      });
    }
    
    return isValid;
  },

  // 创建激励广告实例
  createRewardedVideoAd() {
    // 创建广告实例
    if (wx.createRewardedVideoAd) {
      this.rewardedVideoAd = wx.createRewardedVideoAd({
        adUnitId: 'adunit-9e4cf424d63967f5'
      });

      // 监听广告加载事件
      this.rewardedVideoAd.onLoad(() => {
        console.log('激励广告加载成功');
      });

      // 监听广告错误事件
      this.rewardedVideoAd.onError((err) => {
        console.error('激励广告出错:', err);
        // 广告拉取异常视为播放完毕
        this.setData({
          adCompleted: true
        });
        
        // 如果API已完成，立即停止提示消息
        if (this.data.apiCompleted) {
          this.showMessages(false);
        }
        
        // 检查是否可以导航到结果页
        this.checkNavigationConditions();
      });

      // 监听广告关闭事件
      this.rewardedVideoAd.onClose((res) => {
        console.log('激励广告关闭', res);

        // 判断是否是正常关闭(用户看完了广告)
        if (res && res.isEnded) {
          console.log('激励广告完整观看');
          this.setData({
            adCompleted: true
          });
          
          // 如果API已完成，立即停止提示消息
          if (this.data.apiCompleted) {
            this.showMessages(false);
          }
          
          // 检查是否可以导航到结果页
          this.checkNavigationConditions();
        } else {
          // 不是正常结束时先停止消息循环
          this.showMessages(false);
          
          console.log('激励广告提前关闭');
          // 提示用户广告未播放完毕
          wx.showModal({
            title: '提示',
            content: '广告未播放完毕，无法生成名字，是否继续播放？',
            success: (res) => {
              if (res.confirm) {
                // 用户点击确定，继续播放广告
                this.showMessages(true); // 重新打开提示消息
                this.showRewardedVideoAd(); // 重新播放广告
              } else {
                // 用户点击取消，中断名字生成流程
                this.cancelNameGeneration();
              }
            }
          });
        }
      });
    }
  },

  // 显示激励广告
  showRewardedVideoAd() {
    if (this.rewardedVideoAd) {
      this.rewardedVideoAd.show()
        .catch(err => {
          // 失败重试
          this.rewardedVideoAd.load()
            .then(() => this.rewardedVideoAd.show())
            .catch(err => {
              console.error('激励广告显示失败:', err);
              // 广告显示异常视为播放完毕
              this.setData({
                adCompleted: true
              });
              
              // 如果API已完成，立即停止提示消息
              if (this.data.apiCompleted) {
                this.showMessages(false);
              }
              
              // 检查是否可以导航到结果页
              this.checkNavigationConditions();
            });
        });
    }
  },

  // 取消名字生成
  cancelNameGeneration() {
    // 重置状态
    this.setData({
      isGenerating: false,
      adCompleted: false,
      apiCompleted: false,
      apiResult: null
    });
    
    // 关闭所有提示
    this.showMessages(false);
    
    try {
      wx.hideToast();
    } catch (e) {
      console.error('hideToast error:', e);
    }
    
    try {
      wx.hideLoading();
    } catch (e) {
      console.error('hideLoading error:', e);
    }
  },

  // 检查是否满足导航条件
  checkNavigationConditions() {
    if (this.data.adCompleted && this.data.apiCompleted && this.data.apiResult) {
      // 确保消息循环已关闭
      this.showMessages(false);
      // 导航到结果页
      this.navigateToResultPage(this.data.apiResult);
    }
  },

  // 循环显示提示消息的方法
  showMessages(isShow) {
    // 清除可能存在的旧定时器
    if (this.data.messageTimers.firstTimer) {
      clearTimeout(this.data.messageTimers.firstTimer);
    }
    
    if (this.data.messageTimers.interval) {
      clearInterval(this.data.messageTimers.interval);
    }
    
    if (!isShow) {
      // 如果不需要显示消息，直接返回
      return;
    }
    
    // 使用文化典故取名法的特定提示消息
    const nameGenerationMessages = nameMessages.cultureGenerationMessages;
    let nameMessageIndex = 0;
    
    const showNameGenerationMessage = () => {
      // 先隐藏之前的提示
      try {
        wx.hideToast();
      } catch (e) {
        console.error('hideToast error:', e);
      }
      
      try {
        wx.hideLoading();
      } catch (e) {
        console.error('hideLoading error:', e);
      }
      
      // 显示新的提示 - 设置mask为false，让用户可以点击其他元素
      wx.showToast({
        title: nameGenerationMessages[nameMessageIndex],
        icon: 'none',
        duration: 10000,
        mask: false
      });
      
      // 更新消息索引，循环使用提示
      nameMessageIndex = (nameMessageIndex + 1) % nameGenerationMessages.length;
    };
    
    // 3秒后显示第一次提示
    const firstNameTimer = setTimeout(() => {
      if (this.data.isGenerating) {
        showNameGenerationMessage();
      }
    }, 3000);
    
    // 每4秒更新一次提示，直到请求完成
    const nameGenerationInterval = setInterval(() => {
      if (this.data.isGenerating) {
        showNameGenerationMessage();
      } else {
        clearInterval(nameGenerationInterval);
      }
    }, 4000);
    
    // 保存定时器引用
    this.setData({
      messageTimers: {
        firstTimer: firstNameTimer,
        interval: nameGenerationInterval
      }
    });
  },

  // 生成名字
  generateNames() {
    if (!this.checkFormValid()) {
      wx.showToast({
        title: '请填写期望寄语',
        icon: 'none'
      });
      return;
    }
    
    // 提示用户将播放广告
    wx.showModal({
      title: '提示',
      content: '计算名字大概需要30秒，为了分担服务成本，会播放一段广告，请耐心等待...',
      success: (res) => {
        if (res.confirm) {
          // 用户同意观看广告，开始生成名字流程
          this.startNameGeneration();
        } else {
          // 用户拒绝观看广告，中断流程
          console.log('用户拒绝观看广告');
        }
      }
    });
  },

  // 开始名字生成流程
  startNameGeneration() {
    // 重置状态
    this.setData({
      isGenerating: true,
      adCompleted: false,
      apiCompleted: false,
      apiResult: null
    });

    // 显示初始加载动画 - 确保mask为false允许点击
    wx.showLoading({
      title: '正在推荐名字\n请耐心等待...',
      mask: false
    });
    
    // 启动提示消息循环显示
    this.showMessages(true);
    
    // 准备请求数据并异步调用API
    this.callNameGenerationAPI()
      .then(result => {
        // 保存API结果
        this.setData({
          apiCompleted: true,
          apiResult: result
        });
        
        // 如果广告已完成，立即停止提示消息
        if (this.data.adCompleted) {
          this.showMessages(false);
        }
        
        // 检查是否可以导航到结果页
        this.checkNavigationConditions();
      })
      .catch(error => {
        console.error('生成名字失败:', error);
        this.setData({
          isGenerating: false,
          apiCompleted: true
        });
        
        // 无论成功失败都应该停止提示消息
        this.showMessages(false);
      });

    // 开始播放激励广告
    this.showRewardedVideoAd();
  },

  // 调用API生成名字
  callNameGenerationAPI() {
    // 返回Promise以支持异步流程控制
    return new Promise((resolve, reject) => {
      // 获取姓氏和性别等数据
      const surname = this.data.formData ? this.data.formData.surname : '';
      const gender = this.data.formData ? this.data.formData.gender : 'male';
      const nameLength = this.data.formData ? this.data.formData.nameLength : '2';
      
      // 拼接特质和期望
      const traits = this.data.traits.join('、');
      const expectation = this.data.expectation;
      const optimize_expect = traits + (traits && expectation ? '，' : '') + expectation;
      
      console.log('文化典故页面准备发送的数据:', {
        surname: surname,
        gender: gender,
        nameLength: nameLength,
        optimize_expect: optimize_expect
      });
      
      // 调用真实API生成名字
      const api = require('../../utils/api.js');
      api.generateRealName({
        wuxing: "", // 文化典故法不需要五行
        optimize_expect: optimize_expect, // 期望描述
        surname: surname, // 姓氏
        gender: gender === 'male' ? '男' : '女', // 性别
        nameLength: nameLength, // 名字长度
        preference: "culture", // 取名偏好为文化典故法
        is_rare_character: this.data.formData.disableRareChars ? "y" : "n", 
        is_complex_character: this.data.formData.disableComplexChars ? "y" : "n",
        // 添加定字取名相关参数
        is_fixedname: this.data.formData ? this.data.formData.fixedChar : false,
        fixedposition: this.data.formData ? this.data.formData.fixedPosition : 'first',
        fixed_word: this.data.formData ? this.data.formData.fixedCharValue : '',
        namesNum: this.data.formData.namesNum || 10, // 添加名字生成数量参数
      })
      .then(result => {
        console.log('API返回的名字数据:', result);
        
        // 保存生成的名字数据
        this.saveNamesData(result);
        
        // 返回结果数据，完成Promise
        resolve(result);
      })
      .catch(error => {
        console.error('生成名字API调用失败:', error);
        wx.showToast({
          title: '生成名字失败，请重试',
          icon: 'none'
        });
        
        // 拒绝Promise
        reject(error);
      })
      .finally(() => {
        // 只隐藏loading，不影响消息循环
        try {
          wx.hideLoading();
        } catch (e) {
          console.error('hideLoading error:', e);
        }
      });
    });
  },

  // 保存名字数据到全局和本地存储
  saveNamesData(result) {
    // 获取姓氏和性别等数据
    const surname = this.data.formData ? this.data.formData.surname : '';
    const gender = this.data.formData ? this.data.formData.gender : 'male';
    const nameLength = this.data.formData ? this.data.formData.nameLength : '2';
    
    // 拼接特质和期望
    const traits = this.data.traits.join('、');
    const expectation = this.data.expectation;
    
    // 构建要保存的数据对象
    const namesResultData = {
      surname: surname,
      gender: gender,
      nameLength: nameLength,
      expectation: expectation,
      traits: this.data.traits,
      namesData: result,
      methodType: 'culture',
      // 传递定字取名参数
      is_fixedname: this.data.formData ? this.data.formData.fixedChar : false,
      fixedposition: this.data.formData ? this.data.formData.fixedPosition : 'first',
      fixed_word: this.data.formData ? this.data.formData.fixedCharValue : '',
      disableRareChars: this.data.formData.disableRareChars,
      disableComplexChars: this.data.formData.disableComplexChars
    };
    
    // 将API结果保存到全局变量
    const app = getApp();
    app.globalData = app.globalData || {};
    app.globalData.namesResult = namesResultData;
    
    // 同时也保存到本地存储作为备份
    wx.setStorageSync('namesResultData', namesResultData);
  },

  // 导航到结果页面
  navigateToResultPage(result) {
    // 确保重置生成状态
    this.setData({
      isGenerating: false
    });
    
    // 确保所有提示已关闭
    try {
      wx.hideToast();
    } catch (e) {
      console.error('hideToast error:', e);
    }
    
    try {
      wx.hideLoading();
    } catch (e) {
      console.error('hideLoading error:', e);
    }
    
    // 跳转到结果页面
    wx.navigateTo({
      url: '/pages/results/results?methodType=culture&source=culture&hasData=true',
      success: (res) => {
        // 通过eventChannel传递数据作为备份方式
        res.eventChannel.emit('resultData', {
          surname: this.data.formData ? this.data.formData.surname : '',
          gender: this.data.formData ? this.data.formData.gender : 'male',
          nameLength: this.data.formData ? this.data.formData.nameLength : '2',
          expectation: this.data.expectation,
          traits: this.data.traits,
          namesData: result,
          methodType: 'culture',
          // 传递定字取名参数
          is_fixedname: this.data.formData ? this.data.formData.fixedChar : false,
          fixedposition: this.data.formData ? this.data.formData.fixedPosition : 'first',
          fixed_word: this.data.formData ? this.data.formData.fixedCharValue : '',
          disableRareChars: this.data.formData.disableRareChars,
          disableComplexChars: this.data.formData.disableComplexChars
        });
      },
      fail: (err) => {
        console.error('导航到结果页面失败:', err);
        wx.showToast({
          title: '页面跳转失败',
          icon: 'none',
          duration: 2000
        });
      }
    });
  },

  // 页面卸载时清理资源
  onUnload() {
    // 清理消息定时器
    this.showMessages(false);
    
    // 清理广告相关资源
    if (this.rewardedVideoAd) {
      try {
        // 尝试销毁广告实例，不是所有小程序版本都支持此方法
        if (typeof this.rewardedVideoAd.destroy === 'function') {
          this.rewardedVideoAd.destroy();
        }
      } catch (e) {
        console.error('销毁广告实例失败:', e);
      }
    }
  }
}); 